 /*
 * Blas.cs
 *
 * BLAS provider for INTEL's MKL.
 *
 * Copyright (c) 2005, dnAnalytics. All rights reserved.
 */

namespace dnAnalytics.Nli.Mkl {
	internal sealed class Blas : IBlas {
		private static readonly IBlas instance = new Blas();

		private Blas() {}

		#region Public Members

		public static IBlas Instance {
			get { return instance; }
		}

	
		/// <summary>
		/// Computes a vector-vector dot product.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public float Sdot(int n, float[] x, int incX, float[] y, int incY) {
			return SafeNativeMethods.cblas_sdot(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Computes a vector-vector dot product.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">The vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public double Ddot(int n, double[] x, int incX, double[] y, int incY) {
			return SafeNativeMethods.cblas_ddot(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Computes a vector-vector dot product with extended precision.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public double Dsdot(int n, float[] x, int incX, float[] y, int incY) {
			return SafeNativeMethods.cblas_dsdot(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Computes a vector-vector dot product with extended precision.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="sb">A scalar to be added to the dot product.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, sb otherwise.</returns>	
		public float Sdsdot(int n, float sb, float[] x, int incX, float[] y, int incY) {
			return SafeNativeMethods.cblas_sdsdot(n, sb, x, incX, y, incY);
		}

		
		/// <summary>
		/// Computes a vector-vector dot product.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public ComplexFloat Cdotu_sub(int n, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY) {
			ComplexFloat dotu = new ComplexFloat();
			SafeNativeMethods.cblas_cdotu_sub(n, x, incX, y, incY, ref dotu);
			return dotu;
		}

		
		/// <summary>
		/// Computes the dot product of conjugated vector with another vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public ComplexFloat Cdotc_sub(int n, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY) {
			ComplexFloat dotc = new ComplexFloat();
			SafeNativeMethods.cblas_cdotc_sub(n, x, incX, y, incY, ref dotc);
			return dotc;
		}

		
		/// <summary>
		/// Computes a vector-vector dot product.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public ComplexDouble Zdotu_sub(int n, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY) {
			ComplexDouble dotu = new ComplexDouble();
			SafeNativeMethods.cblas_zdotu_sub(n, x, incX, y, incY, ref dotu);
			return dotu;
		}

		
		/// <summary>
		/// Computes the dot product of conjugated vector with another vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <returns>The dot product if n &gt; 0, 0 otherwise.</returns>
		public ComplexDouble Zdotc_sub(int n, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY) {
			ComplexDouble dotc = new ComplexDouble();
			SafeNativeMethods.cblas_zdotc_sub(n, x, incX, y, incY, ref dotc);
			return dotc;
		}

		
		/// <summary>
		/// Computes the Euclidean norm of a vector.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The Euclidean norm.</returns>
		public float Snrm2(int n, float[] x, int incX) {
			return SafeNativeMethods.cblas_snrm2(n, x, incX);
		}

		
		/// <summary>
		/// Calculate the sum of magnitudes of the vector elements.
		/// </summary>
		/// <param name="n">The order of x.</param>
		/// <param name="x">The vector to sum with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The sum of magnitudes of the vector elements</returns>
		public float Sasum(int n, float[] x, int incX) {
			return SafeNativeMethods.cblas_sasum(n, x, incX);
		}

		
		/// <summary>
		/// Computes the Euclidean norm of a vector.
		/// </summary>
		/// <param name="n">order of the vector.</param>
		/// <param name="x">vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>the Euclidean norm.</returns>
		public double Dnrm2(int n, double[] x, int incX) {
			return SafeNativeMethods.cblas_dnrm2(n, x, incX);
		}

		
		/// <summary>
		/// Calculate the sum of magnitudes of the vector elements.
		/// </summary>
		/// <param name="n">The order of x.</param>
		/// <param name="x">The vector to sum with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The sum of magnitudes of the vector elements</returns>
		public double Dasum(int n, double[] x, int incX) {
			return SafeNativeMethods.cblas_dasum(n, x, incX);
		}

		
		/// <summary>
		/// Computes the Euclidean norm of a vector.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The Euclidean norm.</returns>
		public float Scnrm2(int n, ComplexFloat[] x, int incX) {
			return SafeNativeMethods.cblas_scnrm2(n, x, incX);
		}

		
		/// <summary>
		/// Calculate the sum of magnitudes of the vector elements (the magnitude of if the real part plus the magnitude of the imaginary part).
		/// </summary>
		/// <param name="n">The order of x.</param>
		/// <param name="x">The vector to sum with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>sum of magnitudes of the vector elements</returns>
		public float Scasum(int n, ComplexFloat[] x, int incX) {
			return SafeNativeMethods.cblas_scasum(n, x, incX);
		}

		
		/// <summary>
		/// Computes the Euclidean norm of a vector.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>the Euclidean norm.</returns>
		public double Dznrm2(int n, ComplexDouble[] x, int incX) {
			return SafeNativeMethods.cblas_dznrm2(n, x, incX);
		}

		
		/// <summary>
		/// Calculate the sum of magnitudes of the vector elements (the magnitude of if the real part plus the magnitude of the imaginary part).
		/// </summary>
		/// <param name="n">The order of x.</param>
		/// <param name="x">A vector to sum with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>sum of magnitudes of the vector elements</returns>
		public double Dzasum(int n, ComplexDouble[] x, int incX) {
			return SafeNativeMethods.cblas_dzasum(n, x, incX);
		}

		
		/// <summary>
		/// Returns the position of the element with the largest absolute value.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The position of the element with the largest absolute value.</returns>
		public int Isamax(int n, float[] x, int incX) {
			return SafeNativeMethods.cblas_isamax(n, x, incX);
		}

		
		/// <summary>
		/// Returns the position of the element with the largest absolute value.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The position of the element with the largest absolute value.</returns>
		public int Idamax(int n, double[] x, int incX) {
			return SafeNativeMethods.cblas_idamax(n, x, incX);
		}

		
		/// <summary>
		/// Returns the position of the element with the largest sum of the absolute value of the real component
		/// the absolute value of the imaginary part.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>The position of the element with the largest sum of the absolute value of the real component
		/// the absolute value of the imaginary part.</returns>
		public int Icamax(int n, ComplexFloat[] x, int incX) {
			return SafeNativeMethods.cblas_icamax(n, x, incX);
		}

		
		/// <summary>
		/// Returns the position of the element with the largest sum of the absolute value of the real component
		/// the absolute value of the imaginary part.
		/// </summary>
		/// <param name="n">The order of the vector.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <returns>the position of the element with the largest sum of the absolute value of the real component
		/// the absolute value of the imaginary part.</returns>
		public int Izamax(int n, ComplexDouble[] x, int incX) {
			return SafeNativeMethods.cblas_izamax(n, x, incX);
		}

		
		/// <summary>
		/// Swaps the values of one vector with another vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Sswap(int n, float[] x, int incX, float[] y, int incY) {
			SafeNativeMethods.cblas_sswap(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Copies the values form vector to another, from x to y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector to copy from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector to copy to with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Scopy(int n, float[] x, int incX, float[] y, int incY) {
			SafeNativeMethods.cblas_scopy(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Performs the operation y = alpha*x + y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to multiply <paramref name="x"/> with.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Saxpy(int n, float alpha, float[] x, int incX, float[] y, int incY) {
			SafeNativeMethods.cblas_saxpy(n, alpha, x, incX, y, incY);
		}

		
		/// <summary>
		/// Calculates the values of a Givens rotation.
		/// </summary>
		/// <param name="a">On entry, the x coordinate of a point. On exit, 
		/// it is the r value of a Givens rotation.</param>
		/// <param name="b">On entry, the y coordinate of a point. On exit, 
		/// is is the z value of a Givens rotation.</param>
		/// <param name="c">On exit, it is cosine of the angle of rotation of a Givens rotation.</param>
		/// <param name="s">On exit, it is sine of the angle of rotation of a Givens rotation.</param>
		public void Srotg(ref float a, ref float b, out float c, out float s) {
			SafeNativeMethods.cblas_srotg(ref a, ref b, out c, out s);
		}

		
		/// <summary>
		/// Swaps the values of one vector with another vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dswap(int n, double[] x, int incX, double[] y, int incY) {
			SafeNativeMethods.cblas_dswap(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Copies the values form vector to another, from x to y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector to copy from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector to copy to with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dcopy(int n, double[] x, int incX, double[] y, int incY) {
			SafeNativeMethods.cblas_dcopy(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Performs the operation y = alpha*x + y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to multiply <paramref name="x"/> with.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Daxpy(int n, double alpha, double[] x, int incX, double[] y, int incY) {
			SafeNativeMethods.cblas_daxpy(n, alpha, x, incX, y, incY);
		}

		
		/// <summary>
		/// Calculates the values of a Givens rotation.
		/// </summary>
		/// <param name="a">On entry, the x coordinate of a point. On exit, 
		/// it is the r value of a Givens rotation.</param>
		/// <param name="b">On entry, the y coordinate of a point. On exit, 
		/// is is the z value of a Givens rotation.</param>
		/// <param name="c">On exit, it is cosine of the angle of rotation of a Givens rotation.</param>
		/// <param name="s">On exit, it is sine of the angle of rotation of a Givens rotation.</param>
		public void Drotg(ref double a, ref double b, out double c, out double s) {
			SafeNativeMethods.cblas_drotg(ref a, ref b, out c, out s);
		}

		
		/// <summary>
		/// Swaps the values of one vector with another vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Cswap(int n, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_cswap(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Copies the values form vector to another, from x to y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector to copy from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector to copy to with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Ccopy(int n, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_ccopy(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Performs the operation y = alpha*x + y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to multiply <paramref name="x"/> with.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Caxpy(int n, ComplexFloat alpha, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_caxpy(n, ref alpha, x, incX, y, incY);
		}

		
		/// <summary>
		/// Calculates the values of a Givens rotation.
		/// </summary>
		/// <param name="a">On entry, the x coordinate of a point. On exit, 
		/// it is the r value of a Givens rotation.</param>
		/// <param name="b">On entry, the y coordinate of a point. On exit, 
		/// is is the z value of a Givens rotation.</param>
		/// <param name="c">On exit, it is cosine of the angle of rotation of a Givens rotation.</param>
		/// <param name="s">On exit, it is sine of the angle of rotation of a Givens rotation.</param>
		public void Crotg(ref ComplexFloat a, ref ComplexFloat b, out ComplexFloat c, out ComplexFloat s) {
			SafeNativeMethods.cblas_crotg(ref a, ref b, out c, out s);
		}

		
		/// <summary>
		/// Swaps the values of one vector with another vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>		
		public void Zswap(int n, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zswap(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Copies the values form vector to another, from x to y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">A vector to copy from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector to copy to with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Zcopy(int n, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zcopy(n, x, incX, y, incY);
		}

		
		/// <summary>
		/// Performs the operation y = alpha*x + y.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to multiply <paramref name="x"/> with.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Zaxpy(int n, ComplexDouble alpha, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zaxpy(n, ref alpha, x, incX, y, incY);
		}

		
		/// <summary>
		/// Calculates the values of a Givens rotation.
		/// </summary>
		/// <param name="a">On entry, the x coordinate of a point. On exit, 
		/// it is the r value of a Givens rotation.</param>
		/// <param name="b">On entry, the y coordinate of a point. On exit, 
		/// is is the z value of a Givens rotation.</param>
		/// <param name="c">On exit, it is cosine of the angle of rotation of a Givens rotation.</param>
		/// <param name="s">On exit, it is sine of the angle of rotation of a Givens rotation.</param>
		public void Zrotg(ref ComplexDouble a, ref ComplexDouble b, out ComplexDouble c, out ComplexDouble s) {
			SafeNativeMethods.cblas_zrotg(ref a, ref b, out c, out s);
		}

		
		/// <summary>
		/// Calculates the values of a modified Givens rotation.
		/// </summary>
		/// <param name="d1">On entry, the scale factor for <paramref name="x1"/>. Updated on exit.</param>
		/// <param name="d2">On entry, the scale factor for <paramref name="y1"/>. Updated on exit.</param>
		/// <param name="x1">On entry, the first element x(1) of the input vector.
		/// On exit, <paramref name="x1"/> is overwritten with the rotated element.</param>
		/// <param name="y1">On entry, the second element y(1) of the input vector.
		/// On exit, <paramref name="y1"/> is unchanged.</param>
		/// <param name="p">On exit, p has a length of five and contains an array defining 
		/// the type of transform matrix H constructed.</param>
		public void Srotmg(ref float d1, ref float d2, ref float x1, float y1, out float[] p) {
			p = new float[5];
			SafeNativeMethods.cblas_srotmg(ref d1, ref d2, ref x1, ref y1, p);
		}

		
		/// <summary>
		/// Rotates points on a plane.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">On entry, a vector containing the <paramref name="x"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with c*x + s*y.</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">On entry, a vector containing the <paramref name="y"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).
		/// On exit, the values of <paramref name="y"/>  are over written with c*x - s*y.</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="c">The cosine of the angle of rotation.</param>
		/// <param name="s">The sine of the angle of rotation.</param>
		public void Srot(int n, float[] x, int incX, float[] y, int incY, float c, float s) {
			SafeNativeMethods.cblas_srot(n, x, incX, y, incY, c, s);
		}

		
		/// <summary>
		/// Rotates points on a modified plane.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">On entry, a vector containing the <paramref name="x"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with H[0,0]*x[i] + H[0,1]*y[i].</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">On entry, a vector containing the <paramref name="y"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with H[1,0]*x[i] + H[1,1]*y[i].</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="p">A vector with a length of five defining the transformation matrix H.</param>
		public void Srotm(int n, float[] x, int incX, float[] y, int incY, float[] p) {
			SafeNativeMethods.cblas_srotm(n, x, incX, y, incY, p);
		}

		
		/// <summary>
		/// Calculates the values of a modified Givens rotation.
		/// </summary>
		/// <param name="d1">On entry, the scale factor for <paramref name="x1"/>. Updated on exit.</param>
		/// <param name="d2">On entry, the scale factor for <paramref name="y1"/>. Updated on exit.</param>
		/// <param name="x1">On entry, the first element x(1) of the input vector.
		/// On exit, <paramref name="x1"/> is overwritten with the rotated element.</param>
		/// <param name="y1">On entry, the second element y(1) of the input vector.
		/// On exit, <paramref name="y1"/> is unchanged.</param>
		/// <param name="p">On exit, p has a length of five and contains an array defining 
		/// the type of transform matrix H constructed.</param>
		public void Drotmg(ref double d1, ref double d2, ref double x1, double y1, out double[] p) {
			p = new double[5];
			SafeNativeMethods.cblas_drotmg(ref d1, ref d2, ref x1, ref y1, p);
		}

		
		/// <summary>
		/// Rotates points on a plane.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">On entry, a vector containing the <paramref name="x"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with c*x + s*y.</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">On entry, a vector containing the <paramref name="y"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).
		/// On exit, the values of <paramref name="y"/>  are over written with c*x - s*y.</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="c">The cosine of the angle of rotation.</param>
		/// <param name="s">The sine of the angle of rotation.</param>
		public void Drot(int n, double[] x, int incX, double[] y, int incY, double c, double s) {
			SafeNativeMethods.cblas_drot(n, x, incX, y, incY, c, s);
		}

		
		/// <summary>
		/// Rotates points on a modified plane.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">On entry, a vector containing the <paramref name="x"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with H[0,0]*x[i] + H[0,1]*y[i].</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">On entry, a vector containing the <paramref name="y"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with H[1,0]*x[i] + H[1,1]*y[i].</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="p">A vector with a length of five defining the transformation matrix H.</param>
		public void Drotm(int n, double[] x, int incX, double[] y, int incY, double[] p) {
			SafeNativeMethods.cblas_drotm(n, x, incX, y, incY, p);
		}

		
		/// <summary>
		/// Rotates points on a plane.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">On entry, a vector containing the <paramref name="x"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with c*x + s*y.</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">On entry, a vector containing the <paramref name="y"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).
		/// On exit, the values of <paramref name="y"/>  are over written with c*x - s*y.</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="c">The cosine of the angle of rotation.</param>
		/// <param name="s">The sine of the angle of rotation.</param>
		public void Csrot(int n, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY, float c, float s) {
			SafeNativeMethods.cblas_csrot(n, x, incX, y, incY, c, s);
		}

		
		/// <summary>
		/// Rotates points on a plane.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="x">On entry, a vector containing the <paramref name="x"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).
		/// On exit, the values of <paramref name="x"/>  are over written with c*x + s*y.</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">On entry, a vector containing the <paramref name="y"/> coordinates from with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incY"/>).
		/// On exit, the values of <paramref name="y"/>  are over written with c*x - s*y.</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="c">The cosine of the angle of rotation.</param>
		/// <param name="s">The sine of the angle of rotation.</param>
		public void Zdrot(int n, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY, double c, double s) {
			SafeNativeMethods.cblas_zdrot(n, x, incX, y, incY, c, s);
		}

		
		/// <summary>
		/// Scales a vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to scale <paramref name="x"/> by.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Sscal(int n, float alpha, float[] x, int incX) {
			SafeNativeMethods.cblas_sscal(n, alpha, x, incX);
		}

		
		/// <summary>
		/// Scales a vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to scale <paramref name="x"/> by.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dscal(int n, double alpha, double[] x, int incX) {
			SafeNativeMethods.cblas_dscal(n, alpha, x, incX);
		}

		
		/// <summary>
		/// Scales a vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to scale <paramref name="x"/> by.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Cscal(int n, ComplexFloat alpha, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_cscal(n, ref alpha, x, incX);
		}

		
		/// <summary>
		/// Scales a vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to scale <paramref name="x"/> by.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Zscal(int n, ComplexDouble alpha, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_zscal(n, ref alpha, x, incX);
		}

		
		/// <summary>
		/// Scales a vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to scale <paramref name="x"/> by.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Csscal(int n, float alpha, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_csscal(n, alpha, x, incX);
		}

		
		/// <summary>
		/// Scales a vector.
		/// </summary>
		/// <param name="n">The order of the vectors.</param>
		/// <param name="alpha">The scalar to scale <paramref name="x"/> by.</param>
		/// <param name="x">A vector with a length of at least 1+(<paramref name="n"/>-1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Zdscal(int n, double alpha, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_zdscal(n, alpha, x, incX);
		}

		
		/// <summary>
		/// Multiplies a matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Sgemv(BlasOrderType order, BlasTransType transA, int m, int n, float alpha, float[] a, int lda, float[] x, int incX, float beta, float[] y, int incY) {
			SafeNativeMethods.cblas_sgemv(order, transA, m, n, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a band matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="kl">The number of sub-diagonals of <paramref name="a"/>. <paramref name="kl"/>&gt;=0.</param>
		/// <param name="ku">The number of super-diagonals of <paramref name="a"/>. <paramref name="ku"/>&gt;=0.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least ku+kl+1.</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Sgbmv(BlasOrderType order, BlasTransType transA, int m, int n, int kl, int ku, float alpha, float[] a, int lda, float[] x, int incX, float beta, float[] y, int incY) {
			SafeNativeMethods.cblas_sgbmv(order, transA, m, n, kl, ku, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a triangular matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Strmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, float[] a, int lda, float[] x, int incX) {
			SafeNativeMethods.cblas_strmv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a triangular, band matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Stbmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, float[] a, int lda, float[] x, int incX) {
			SafeNativeMethods.cblas_stbmv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a packed triangular matrix (a) and a vector (x). x =  ap * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="ap"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix to multiply. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Stpmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, float[] ap, float[] x, int incX) {
			SafeNativeMethods.cblas_stpmv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Strsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, float[] a, int lda, float[] x, int incX) {
			SafeNativeMethods.cblas_strsv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular, band matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Stbsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, float[] a, int lda, float[] x, int incX) {
			SafeNativeMethods.cblas_stbsv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (ap) is a packed triangular matrix. Solves for x in, ap * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix containing the equation coefficients. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Stpsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, float[] ap, float[] x, int incX) {
			SafeNativeMethods.cblas_stpsv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Multiplies a matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dgemv(BlasOrderType order, BlasTransType transA, int m, int n, double alpha, double[] a, int lda, double[] x, int incX, double beta, double[] y, int incY) {
			SafeNativeMethods.cblas_dgemv(order, transA, m, n, alpha, a, lda, x, incX, beta, y, incY);
		}


		/// <summary>
		/// Multiplies a band matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="kl">The number of sub-diagonals of <paramref name="a"/>. <paramref name="kl"/>&gt;=0.</param>
		/// <param name="ku">The number of super-diagonals of <paramref name="a"/>. <paramref name="ku"/>&gt;=0.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least ku+kl+1.</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dgbmv(BlasOrderType order, BlasTransType transA, int m, int n, int kl, int ku, double alpha, double[] a, int lda, double[] x, int incX, double beta, double[] y, int incY) {
			SafeNativeMethods.cblas_dgbmv(order, transA, m, n, kl, ku, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a triangular matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dtrmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, double[] a, int lda, double[] x, int incX) {
			SafeNativeMethods.cblas_dtrmv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a triangular, band matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dtbmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, double[] a, int lda, double[] x, int incX) {
			SafeNativeMethods.cblas_dtbmv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a packed triangular matrix (a) and a vector (x). x =  ap * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="ap"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix to multiply. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dtpmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, double[] ap, double[] x, int incX) {
			SafeNativeMethods.cblas_dtpmv(order, uplo, transA, diag, n, ap, x, incX);
		}


		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dtrsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, double[] a, int lda, double[] x, int incX) {
			SafeNativeMethods.cblas_dtrsv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular, band matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dtbsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, double[] a, int lda, double[] x, int incX) {
			SafeNativeMethods.cblas_dtbsv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (ap) is a packed triangular matrix. Solves for x in, ap * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix containing the equation coefficients. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Dtpsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, double[] ap, double[] x, int incX) {
			SafeNativeMethods.cblas_dtpsv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Multiplies a matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Cgemv(BlasOrderType order, BlasTransType transA, int m, int n, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX, ComplexFloat beta, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_cgemv(order, transA, m, n, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a band matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="kl">The number of sub-diagonals of <paramref name="a"/>. <paramref name="kl"/>&gt;=0.</param>
		/// <param name="ku">The number of super-diagonals of <paramref name="a"/>. <paramref name="ku"/>&gt;=0.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least ku+kl+1.</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Cgbmv(BlasOrderType order, BlasTransType transA, int m, int n, int kl, int ku, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX, ComplexFloat beta, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_cgbmv(order, transA, m, n, kl, ku, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a triangular matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ctrmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_ctrmv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a triangular, band matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ctbmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_ctbmv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a packed triangular matrix (a) and a vector (x). x =  ap * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="ap"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix to multiply. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ctpmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexFloat[] ap, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_ctpmv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ctrsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_ctrsv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular, band matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ctbsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_ctbsv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (ap) is a packed triangular matrix. Solves for x in, ap * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix containing the equation coefficients. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ctpsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexFloat[] ap, ComplexFloat[] x, int incX) {
			SafeNativeMethods.cblas_ctpsv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Multiplies a matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="m"/>).</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Zgemv(BlasOrderType order, BlasTransType transA, int m, int n, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX, ComplexDouble beta, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zgemv(order, transA, m, n, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a band matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="kl">The number of sub-diagonals of <paramref name="a"/>. <paramref name="kl"/>&gt;=0.</param>
		/// <param name="ku">The number of super-diagonals of <paramref name="a"/>. <paramref name="ku"/>&gt;=0.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least ku+kl+1.</param>
		/// <param name="x">The vector to multiply with. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then x must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). Otherwise, x must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. If <paramref name="transA"/> == <see cref="BlasTransType.NoTrans"/>, then y must have a 
		/// length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incY"/>). Otherwise, y must have a 
		/// length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Zgbmv(BlasOrderType order, BlasTransType transA, int m, int n, int kl, int ku, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX, ComplexDouble beta, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zgbmv(order, transA, m, n, kl, ku, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a triangular matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ztrmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_ztrmv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a triangular, band matrix (a) and a vector (x). x = a * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ztbmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_ztbmv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Multiplies a packed triangular matrix (a) and a vector (x). x =  ap * x.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="ap"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix to multiply. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ztpmv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexDouble[] ap, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_ztpmv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ztrsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_ztrsv(order, uplo, transA, diag, n, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (a) is a triangular, band matrix. Solves for x in, a * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="a"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="a"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals or sub-diagonals.</param>
		/// <param name="a">The matrix containing the equation coefficients. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ztbsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, int k, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_ztbsv(order, uplo, transA, diag, n, k, a, lda, x, incX);
		}

		
		/// <summary>
		/// Solves a system of linear equations when a matrix (ap) is a packed triangular matrix. Solves for x in, ap * x = b
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="transA">The <see cref="BlasTransType"/> specifying whether and how to transpose <paramref name="ap"/>.</param>
		/// <param name="diag">The <see cref="BlasDiagType"/> specifying if <paramref name="ap"/> is unit triangular or not.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="ap">The matrix containing the equation coefficients. The length of <paramref name="ap"/> must be at least (<paramref name="n"/>*(<paramref name="n"/> + 1))/2.</param>
		/// <param name="x">On entry, x contains the values of the b vector. On exit, x contains the solution values. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>). </param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		public void Ztpsv(BlasOrderType order, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int n, ComplexDouble[] ap, ComplexDouble[] x, int incX) {
			SafeNativeMethods.cblas_ztpsv(order, uplo, transA, diag, n, ap, x, incX);
		}

		
		/// <summary>
		/// Multiplies a symmetric matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Ssymv(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, float[] a, int lda, float[] x, int incX, float beta, float[] y, int incY) {
			SafeNativeMethods.cblas_ssymv(order, uplo, n, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a symmetric, band matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Ssbmv(BlasOrderType order, BlasUpLoType uplo, int n, int k, float alpha, float[] a, int lda, float[] x, int incX, float beta, float[] y, int incY) {
			SafeNativeMethods.cblas_ssbmv(order, uplo, n, k, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a packed symmetric matrix (ap) and a vector (x) and adds the result to another vector (y). y = alpha * ap * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="n">The number of columns of <paramref name="ap"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="ap"/> by.</param>
		/// <param name="ap">The matrix to multiply. <paramref name="ap"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*ap*x. On exit, contains
		/// the result of alpha*ap*x + beta*y. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Sspmv(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, float[] ap, float[] x, int incX, float beta, float[] y, int incY) {
			SafeNativeMethods.cblas_sspmv(order, uplo, n, alpha, ap, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// A rank-1 update of a general matrix. a = alpha * x * y' + a.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to multiply the matrix created by <paramref name="x"/> and <paramref name="y"/>' with.</param>
		/// <param name="x">The vector to multiply with the transpose of <paramref name="y"/>. x must have a length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">The vector to multiply with <paramref name="x"/>. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="a">On entry, the matrix to add to the product of <paramref name="x"/> and <paramref name="y"/>'. On exit, 
		/// it contains the result of alpha*x*y'+a.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least m.</param>
		public void Sger(BlasOrderType order, int m, int n, float alpha, float[] x, int incX, float[] y, int incY, float[] a, int lda) {
			SafeNativeMethods.cblas_sger(order, m, n, alpha, x, incX, y, incY, a, lda);
		}

		
		public void Ssyr(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, float[] x, int incX, float[] a, int lda) {
			SafeNativeMethods.cblas_ssyr(order, uplo, n, alpha, x, incX, a, lda);
		}

		
		public void Sspr(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, float[] x, int incX, float[] ap) {
			SafeNativeMethods.cblas_sspr(order, uplo, n, alpha, x, incX, ap);
		}

		
		public void Ssyr2(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, float[] x, int incX, float[] y, int incY, float[] a, int lda) {
			SafeNativeMethods.cblas_ssyr2(order, uplo, n, alpha, x, incX, y, incY, a, lda);
		}

		
		public void Sspr2(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, float[] x, int incX, float[] y, int incY, float[] a) {
			SafeNativeMethods.cblas_sspr2(order, uplo, n, alpha, x, incX, y, incY, a);
		}

		
		/// <summary>
		/// Multiplies a symmetric matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> &gt;= max(1,<paramref name="n"/>).</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dsymv(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, double[] a, int lda, double[] x, int incX, double beta, double[] y, int incY) {
			SafeNativeMethods.cblas_dsymv(order, uplo, n, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a symmetric, band matrix (a) and a vector (x) and adds the result to another vector (y). y = alpha * a * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="a"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="k">The number of super-diagonals of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="a"/> by.</param>
		/// <param name="a">The matrix to multiply. <paramref name="a"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least k+1.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*a*x. On exit, contains
		/// the result of alpha*a*x + beta*y. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dsbmv(BlasOrderType order, BlasUpLoType uplo, int n, int k, double alpha, double[] a, int lda, double[] x, int incX, double beta, double[] y, int incY) {
			SafeNativeMethods.cblas_dsbmv(order, uplo, n, k, alpha, a, lda, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// Multiplies a packed symmetric matrix (ap) and a vector (x) and adds the result to another vector (y). y = alpha * ap * x + beta * y.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="ap"/>.</param>
		/// <param name="uplo">The <see cref="BlasUpLoType"/> specifying if <paramref name="ap"/> is an upper or lower
		/// triangular matrix.</param>
		/// <param name="n">The number of columns of <paramref name="ap"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to scale <paramref name="ap"/> by.</param>
		/// <param name="ap">The matrix to multiply. <paramref name="ap"/> must have the dimensions <paramref name="lda"/> by <paramref name="n"/>.</param>
		/// <param name="x">The vector to multiply with. x must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="beta">A scalar to scale <paramref name="y"/> by.</param>
		/// <param name="y">On entry, the vector to add to the result of alpha*ap*x. On exit, contains
		/// the result of alpha*ap*x + beta*y. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		public void Dspmv(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, double[] ap, double[] x, int incX, double beta, double[] y, int incY) {
			SafeNativeMethods.cblas_dspmv(order, uplo, n, alpha, ap, x, incX, beta, y, incY);
		}

		
		/// <summary>
		/// A rank-1 update of a general matrix. a = alpha * x * y' + a.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to multiply the matrix created by <paramref name="x"/> and <paramref name="y"/>' with.</param>
		/// <param name="x">The vector to multiply with the transpose of <paramref name="y"/>. x must have a length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">The vector to multiply with <paramref name="x"/>. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="a">On entry, the matrix to add to the product of <paramref name="x"/> and <paramref name="y"/>'. On exit, 
		/// it contains the result of alpha*x*y'+a.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least m.</param>
		public void Dger(BlasOrderType order, int m, int n, double alpha, double[] x, int incX, double[] y, int incY, double[] a, int lda) {
			SafeNativeMethods.cblas_dger(order, m, n, alpha, x, incX, y, incY, a, lda);
		}

		
		public void Dsyr(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, double[] x, int incX, double[] a, int lda) {
			SafeNativeMethods.cblas_dsyr(order, uplo, n, alpha, x, incX, a, lda);
		}

		
		public void Dspr(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, double[] x, int incX, double[] ap) {
			SafeNativeMethods.cblas_dspr(order, uplo, n, alpha, x, incX, ap);
		}

		
		public void Dsyr2(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, double[] x, int incX, double[] y, int incY, double[] a, int lda) {
			SafeNativeMethods.cblas_dsyr2(order, uplo, n, alpha, x, incX, y, incY, a, lda);
		}

		
		public void Dspr2(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, double[] x, int incX, double[] y, int incY, double[] a) {
			SafeNativeMethods.cblas_dspr2(order, uplo, n, alpha, x, incX, y, incY, a);
		}

		
		public void Chemv(BlasOrderType order, BlasUpLoType uplo, int n, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX, ComplexFloat beta, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_chemv(order, uplo, n, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		public void Chbmv(BlasOrderType order, BlasUpLoType uplo, int n, int k, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] x, int incX, ComplexFloat beta, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_chbmv(order, uplo, n, k, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		public void Chpmv(BlasOrderType order, BlasUpLoType uplo, int n, ComplexFloat alpha, ComplexFloat[] ap, ComplexFloat[] x, int incX, ComplexFloat beta, ComplexFloat[] y, int incY) {
			SafeNativeMethods.cblas_chpmv(order, uplo, n, ref alpha, ap, x, incX, ref beta, y, incY);
		}

		
		/// <summary>
		/// A rank-1 update of a general matrix. a = alpha * x * y' + a.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to multiply the matrix created by <paramref name="x"/> and <paramref name="y"/>' with.</param>
		/// <param name="x">The vector to multiply with the transpose of <paramref name="y"/>. x must have a length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">The vector to multiply with <paramref name="x"/>. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="a">On entry, the matrix to add to the product of <paramref name="x"/> and <paramref name="y"/>'. On exit, 
		/// it contains the result of alpha*x*y'+a.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least m.</param>
		public void Cgeru(BlasOrderType order, int m, int n, ComplexFloat alpha, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY, ComplexFloat[] a, int lda) {
			SafeNativeMethods.cblas_cgeru(order, m, n, ref alpha, x, incX, y, incY, a, lda);
		}

		
		public void Cgerc(BlasOrderType order, int m, int n, ComplexFloat alpha, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY, ComplexFloat[] a, int lda) {
			SafeNativeMethods.cblas_cgerc(order, m, n, ref alpha, x, incX, y, incY, a, lda);
		}

		
		public void Cher(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, ComplexFloat[] x, int incX, ComplexFloat[] a, int lda) {
			SafeNativeMethods.cblas_cher(order, uplo, n, alpha, x, incX, a, lda);
		}

		
		public void Chpr(BlasOrderType order, BlasUpLoType uplo, int n, float alpha, ComplexFloat[] x, int incX, ComplexFloat[] a) {
			SafeNativeMethods.cblas_chpr(order, uplo, n, alpha, x, incX, a);
		}

		
		public void Cher2(BlasOrderType order, BlasUpLoType uplo, int n, ComplexFloat alpha, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY, ComplexFloat[] a, int lda) {
			SafeNativeMethods.cblas_cher2(order, uplo, n, ref alpha, x, incX, y, incY, a, lda);
		}

		
		public void Chpr2(BlasOrderType order, BlasUpLoType uplo, int n, ComplexFloat alpha, ComplexFloat[] x, int incX, ComplexFloat[] y, int incY, ComplexFloat[] ap) {
			SafeNativeMethods.cblas_chpr2(order, uplo, n, ref alpha, x, incX, y, incY, ap);
		}

		
		public void Zhemv(BlasOrderType order, BlasUpLoType uplo, int n, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX, ComplexDouble beta, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zhemv(order, uplo, n, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		public void Zhbmv(BlasOrderType order, BlasUpLoType uplo, int n, int k, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] x, int incX, ComplexDouble beta, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zhbmv(order, uplo, n, k, ref alpha, a, lda, x, incX, ref beta, y, incY);
		}

		
		public void Zhpmv(BlasOrderType order, BlasUpLoType uplo, int n, ComplexDouble alpha, ComplexDouble[] ap, ComplexDouble[] x, int incX, ComplexDouble beta, ComplexDouble[] y, int incY) {
			SafeNativeMethods.cblas_zhpmv(order, uplo, n, ref alpha, ap, x, incX, ref beta, y, incY);
		}

		
		/// <summary>
		/// A rank-1 update of a general matrix. a = alpha * x * y' + a.
		/// </summary>
		/// <param name="order">The <see cref="BlasOrderType"/> specifying the column order of <paramref name="a"/>.</param>
		/// <param name="m">The number of rows of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="n">The number of columns of <paramref name="a"/>. Must be greater than zero.</param>
		/// <param name="alpha">A scalar to multiply the matrix created by <paramref name="x"/> and <paramref name="y"/>' with.</param>
		/// <param name="x">The vector to multiply with the transpose of <paramref name="y"/>. x must have a length of at least 1 + (<paramref name="m"/> - 1)*abs(<paramref name="incX"/>).</param>
		/// <param name="incX">The number of elements to increment the index of <paramref name="x"/> by.</param>
		/// <param name="y">The vector to multiply with <paramref name="x"/>. y must have a length of at least 1 + (<paramref name="n"/> - 1)*abs(<paramref name="incY"/>).</param>
		/// <param name="incY">The number of elements to increment the index of <paramref name="y"/> by.</param>
		/// <param name="a">On entry, the matrix to add to the product of <paramref name="x"/> and <paramref name="y"/>'. On exit, 
		/// it contains the result of alpha*x*y'+a.</param>
		/// <param name="lda">The first dimension of <paramref name="a"/>. <paramref name="lda"/> must be at least m.</param>
		public void Zgeru(BlasOrderType order, int m, int n, ComplexDouble alpha, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY, ComplexDouble[] a, int lda) {
			SafeNativeMethods.cblas_zgeru(order, m, n, ref alpha, x, incX, y, incY, a, lda);
		}

		
		public void Zgerc(BlasOrderType order, int m, int n, ComplexDouble alpha, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY, ComplexDouble[] a, int lda) {
			SafeNativeMethods.cblas_zgerc(order, m, n, ref alpha, x, incX, y, incY, a, lda);
		}

		
		public void Zher(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, ComplexDouble[] x, int incX, ComplexDouble[] a, int lda) {
			SafeNativeMethods.cblas_zher(order, uplo, n, alpha, x, incX, a, lda);
		}

		
		public void Zhpr(BlasOrderType order, BlasUpLoType uplo, int n, double alpha, ComplexDouble[] x, int incX, ComplexDouble[] a) {
			SafeNativeMethods.cblas_zhpr(order, uplo, n, alpha, x, incX, a);
		}

		
		public void Zher2(BlasOrderType order, BlasUpLoType uplo, int n, ComplexDouble alpha, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY, ComplexDouble[] a, int lda) {
			SafeNativeMethods.cblas_zher2(order, uplo, n, ref alpha, x, incX, y, incY, a, lda);
		}

		
		public void Zhpr2(BlasOrderType order, BlasUpLoType uplo, int n, ComplexDouble alpha, ComplexDouble[] x, int incX, ComplexDouble[] y, int incY, ComplexDouble[] ap) {
			SafeNativeMethods.cblas_zhpr2(order, uplo, n, ref alpha, x, incX, y, incY, ap);
		}

		
		public void Sgemm(BlasOrderType order, BlasTransType transA, BlasTransType transB, int m, int n, int k, float alpha, float[] a, int lda, float[] b, int ldb, float beta, float[] c, int ldc) {
			SafeNativeMethods.cblas_sgemm(order, transA, transB, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Ssymm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, int m, int n, float alpha, float[] a, int lda, float[] b, int ldb, float beta, float[] c, int ldc) {
			SafeNativeMethods.cblas_ssymm(order, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Ssyrk(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, float alpha, float[] a, int lda, float beta, float[] c, int ldc) {
			SafeNativeMethods.cblas_ssyrk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
		}

		
		public void Ssyr2k(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, float alpha, float[] a, int lda, float[] b, int ldb, float beta, float[] c, int ldc) {
			SafeNativeMethods.cblas_ssyr2k(order, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Strmm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, float alpha, float[] a, int lda, float[] b, int ldb) {
			SafeNativeMethods.cblas_strmm(order, side, uplo, transA, diag, m, n, alpha, a, lda, b, ldb);
		}

		
		public void Strsm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, float alpha, float[] a, int lda, float[] b, int ldb) {
			SafeNativeMethods.cblas_strsm(order, side, uplo, transA, diag, m, n, alpha, a, lda, b, ldb);
		}

		
		public void Dgemm(BlasOrderType order, BlasTransType transA, BlasTransType transB, int m, int n, int k, double alpha, double[] a, int lda, double[] b, int ldb, double beta, double[] c, int ldc) {
			SafeNativeMethods.cblas_dgemm(order, transA, transB, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Dsymm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, int m, int n, double alpha, double[] a, int lda, double[] b, int ldb, double beta, double[] c, int ldc) {
			SafeNativeMethods.cblas_dsymm(order, side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Dsyrk(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, double alpha, double[] a, int lda, double beta, double[] c, int ldc) {
			SafeNativeMethods.cblas_dsyrk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
		}

		
		public void Dsyr2k(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, double alpha, double[] a, int lda, double[] b, int ldb, double beta, double[] c, int ldc) {
			SafeNativeMethods.cblas_dsyr2k(order, uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Dtrmm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, double alpha, double[] a, int lda, double[] b, int ldb) {
			SafeNativeMethods.cblas_dtrmm(order, side, uplo, transA, diag, m, n, alpha, a, lda, b, ldb);
		}

		
		public void Dtrsm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, double alpha, double[] a, int lda, double[] b, int ldb) {
			SafeNativeMethods.cblas_dtrsm(order, side, uplo, transA, diag, m, n, alpha, a, lda, b, ldb);
		}

		
		public void Cgemm(BlasOrderType order, BlasTransType transA, BlasTransType transB, int m, int n, int k, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_cgemm(order, transA, transB, m, n, k, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Csymm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, int m, int n, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_csymm(order, side, uplo, m, n, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Csyrk(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_csyrk(order, uplo, trans, n, k, ref alpha, a, lda, ref beta, c, ldc);
		}

		
		public void Csyr2k(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_csyr2k(order, uplo, trans, n, k, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Ctrmm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb) {
			SafeNativeMethods.cblas_ctrmm(order, side, uplo, transA, diag, m, n, ref alpha, a, lda, b, ldb);
		}

		
		public void Ctrsm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb) {
			SafeNativeMethods.cblas_ctrsm(order, side, uplo, transA, diag, m, n, ref alpha, a, lda, b, ldb);
		}

		
		public void Zgemm(BlasOrderType order, BlasTransType transA, BlasTransType transB, int m, int n, int k, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zgemm(order, transA, transB, m, n, k, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Zsymm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, int m, int n, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zsymm(order, side, uplo, m, n, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Zsyrk(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zsyrk(order, uplo, trans, n, k, ref alpha, a, lda, ref beta, c, ldc);
		}

		
		public void Zsyr2k(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zsyr2k(order, uplo, trans, n, k, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Ztrmm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb) {
			SafeNativeMethods.cblas_ztrmm(order, side, uplo, transA, diag, m, n, ref alpha, a, lda, b, ldb);
		}

		
		public void Ztrsm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, BlasTransType transA, BlasDiagType diag, int m, int n, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb) {
			SafeNativeMethods.cblas_ztrsm(order, side, uplo, transA, diag, m, n, ref alpha, a, lda, b, ldb);
		}

		
		public void Chemm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, int m, int n, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, ComplexFloat beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_chemm(order, side, uplo, m, n, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Cherk(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, float alpha, ComplexFloat[] a, int lda, float beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_cherk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
		}

		
		public void Cher2k(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, ComplexFloat alpha, ComplexFloat[] a, int lda, ComplexFloat[] b, int ldb, float beta, ComplexFloat[] c, int ldc) {
			SafeNativeMethods.cblas_cher2k(order, uplo, trans, n, k, ref alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		public void Zhemm(BlasOrderType order, BlasSideType side, BlasUpLoType uplo, int m, int n, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, ComplexDouble beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zhemm(order, side, uplo, m, n, ref alpha, a, lda, b, ldb, ref beta, c, ldc);
		}

		
		public void Zherk(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, double alpha, ComplexDouble[] a, int lda, double beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zherk(order, uplo, trans, n, k, alpha, a, lda, beta, c, ldc);
		}

		
		public void Zher2k(BlasOrderType order, BlasUpLoType uplo, BlasTransType trans, int n, int k, ComplexDouble alpha, ComplexDouble[] a, int lda, ComplexDouble[] b, int ldb, double beta, ComplexDouble[] c, int ldc) {
			SafeNativeMethods.cblas_zher2k(order, uplo, trans, n, k, ref alpha, a, lda, b, ldb, beta, c, ldc);
		}

		
		#endregion Public Members
	}
}